package com.rybbaby.tss.core.redis;

import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import redis.clients.jedis.BinaryClient.LIST_POSITION;
import redis.clients.jedis.BinaryJedisPubSub;
import redis.clients.jedis.BitOP;
import redis.clients.jedis.BitPosParams;
import redis.clients.jedis.Client;
import redis.clients.jedis.DebugParams;
import redis.clients.jedis.GeoCoordinate;
import redis.clients.jedis.GeoRadiusResponse;
import redis.clients.jedis.GeoUnit;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisCluster.Reset;
import redis.clients.jedis.JedisMonitor;
import redis.clients.jedis.JedisPubSub;
import redis.clients.jedis.Pipeline;
import redis.clients.jedis.ScanParams;
import redis.clients.jedis.ScanResult;
import redis.clients.jedis.SortingParams;
import redis.clients.jedis.Transaction;
import redis.clients.jedis.Tuple;
import redis.clients.jedis.ZParams;
import redis.clients.jedis.params.geo.GeoRadiusParam;
import redis.clients.jedis.params.sortedset.ZAddParams;
import redis.clients.jedis.params.sortedset.ZIncrByParams;
import redis.clients.util.Pool;
import redis.clients.util.Slowlog;

/**
 * redis 客户端
 *
 * @author 谢进伟
 * @description
 * @createDate 2016年12月7日 下午4:31:59
 */
public class RedisClient {

	/**redis是否可用
	 * @return
	 */
	public static boolean isCanUse(){
		Jedis jedis = null;
		try {
			jedis = RedisFactory.getJedis();
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis!=null){
				jedis.close();
			}
		}
		return jedis != null;
	}

	public static String set(String key , String value) {
		Jedis jedis = null;
		String result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.set(key , value);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static String set(String key , String value , String nxxx , String expx , long time) {
		Jedis jedis = null;
		String result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.set(key , value , nxxx , expx , time);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static String get(String key) {
		Jedis jedis = null;
		String result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.get(key);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long exists(String ... keys) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.exists(keys);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Boolean exists(String key) {
		Jedis jedis = null;
		Boolean result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.exists(key);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long del(String ... keys) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.del(keys);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long del(String key) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.del(key);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static String type(String key) {
		Jedis jedis = null;
		String result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.type(key);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Set<String> keys(String pattern) {
		Jedis jedis = null;
		Set<String> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.keys(pattern);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static String randomKey() {
		Jedis jedis = null;
		String result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.randomKey();
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static String rename(String oldkey , String newkey) {
		Jedis jedis = null;
		String result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.rename(oldkey , newkey);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long renamenx(String oldkey , String newkey) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.renamenx(oldkey , newkey);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long expire(String key , int seconds) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.expire(key , seconds);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long expireAt(String key , long unixTime) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.expireAt(key , unixTime);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long ttl(String key) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.ttl(key);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long move(String key , int dbIndex) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.move(key , dbIndex);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static String getSet(String key , String value) {
		Jedis jedis = null;
		String result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.getSet(key , value);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static List<String> mget(String ... keys) {
		Jedis jedis = null;
		List<String> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.mget(keys);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long setnx(String key , String value) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.setnx(key , value);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static String setex(String key , int seconds , String value) {
		Jedis jedis = null;
		String result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.setex(key , seconds , value);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static String mset(String ... keysvalues) {
		Jedis jedis = null;
		String result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.mset(keysvalues);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long msetnx(String ... keysvalues) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.msetnx(keysvalues);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long decrBy(String key , long integer) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.decrBy(key , integer);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long decr(String key) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.decr(key);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long incrBy(String key , long integer) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.incrBy(key , integer);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Double incrByFloat(String key , double value) {
		Jedis jedis = null;
		Double result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.incrByFloat(key , value);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long incr(String key) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.incr(key);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long append(String key , String value) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.append(key , value);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static String substr(String key , int start , int end) {
		Jedis jedis = null;
		String result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.substr(key , start , end);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long hset(String key , String field , String value) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.hset(key , field , value);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static String hget(String key , String field) {
		Jedis jedis = null;
		String result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.hget(key , field);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long hsetnx(String key , String field , String value) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.hsetnx(key , field , value);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static String hmset(String key , Map<String , String> hash) {
		Jedis jedis = null;
		String result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.hmset(key , hash);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static List<String> hmget(String key , String ... fields) {
		Jedis jedis = null;
		List<String> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.hmget(key , fields);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long hincrBy(String key , String field , long value) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.hincrBy(key , field , value);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Double hincrByFloat(String key , String field , double value) {
		Jedis jedis = null;
		Double result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.hincrByFloat(key , field , value);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Boolean Boolean(String key , String field) {
		Jedis jedis = null;
		Boolean result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.hexists(key , field);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long hdel(String key , String ... fields) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.hdel(key , fields);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long hlen(String key) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.hlen(key);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Set<String> hkeys(String key) {
		Jedis jedis = null;
		Set<String> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.hkeys(key);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static List<String> hvals(String key) {
		Jedis jedis = null;
		List<String> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.hvals(key);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Map<String , String> hgetAll(String key) {
		Jedis jedis = null;
		Map<String , String> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.hgetAll(key);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long rpush(String key , String ... strings) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.rpush(key , strings);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long lpush(String key , String ... strings) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.lpush(key , strings);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long llen(String key) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.llen(key);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static List<String> lrange(String key , long start , long end) {
		Jedis jedis = null;
		List<String> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.lrange(key , start , end);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static String ltrim(String key , long start , long end) {
		Jedis jedis = null;
		String result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.ltrim(key , start , end);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static String lindex(String key , long index) {
		Jedis jedis = null;
		String result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.lindex(key , index);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static String lset(String key , long index , String value) {
		Jedis jedis = null;
		String result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.lset(key , index , value);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long lrem(String key , long count , String value) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.lrem(key , count , value);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static String lpop(String key) {
		Jedis jedis = null;
		String result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.lpop(key);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static String rpop(String key) {
		Jedis jedis = null;
		String result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.rpop(key);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static String rpoplpush(String srckey , String dstkey) {
		Jedis jedis = null;
		String result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.rpoplpush(srckey , dstkey);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long sadd(String key , String ... members) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.sadd(key , members);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Set<String> smembers(String key) {
		Jedis jedis = null;
		Set<String> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.smembers(key);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long srem(String key , String ... members) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.srem(key , members);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static String spop(String key) {
		Jedis jedis = null;
		String result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.spop(key);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Set<String> spop(String key , long count) {
		Jedis jedis = null;
		Set<String> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.spop(key , count);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long smove(String srckey , String dstkey , String member) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.smove(srckey , dstkey , member);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long scard(String key) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.scard(key);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Boolean sismember(String key , String member) {
		Jedis jedis = null;
		Boolean result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.sismember(key , member);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Set<String> sinter(String ... keys) {
		Jedis jedis = null;
		Set<String> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.sinter(keys);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long sinterstore(String dstkey , String ... keys) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.sinterstore(dstkey , keys);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Set<String> sunion(String ... keys) {
		Jedis jedis = null;
		Set<String> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.sunion(keys);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long sunionstore(String dstkey , String ... keys) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.sunionstore(dstkey , keys);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Set<String> sdiff(String ... keys) {
		Jedis jedis = null;
		Set<String> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.sdiff(keys);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long sdiffstore(String dstkey , String ... keys) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.sdiffstore(dstkey , keys);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static String srandmember(String key) {
		Jedis jedis = null;
		String result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.srandmember(key);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static List<String> srandmember(String key , int count) {
		Jedis jedis = null;
		List<String> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.srandmember(key , count);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long zadd(String key , double score , String member) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.zadd(key , score , member);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long zadd(String key , double score , String member , ZAddParams params) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.zadd(key , score , member , params);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long zadd(String key , Map<String , Double> scoreMembers) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.zadd(key , scoreMembers);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long zadd(String key , Map<String , Double> scoreMembers , ZAddParams params) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.zadd(key , scoreMembers , params);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Set<String> zrange(String key , long start , long end) {
		Jedis jedis = null;
		Set<String> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.zrange(key , start , end);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long zrem(String key , String ... members) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.zrem(key , members);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Double zincrby(String key , double score , String member) {
		Jedis jedis = null;
		Double result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.zincrby(key , score , member);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Double zincrby(String key , double score , String member , ZIncrByParams params) {
		Jedis jedis = null;
		Double result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.zincrby(key , score , member , params);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long zrank(String key , String member) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.zrank(key , member);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long zrevrank(String key , String member) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.zrevrank(key , member);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Set<String> zrevrange(String key , long start , long end) {
		Jedis jedis = null;
		Set<String> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.zrevrange(key , start , end);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Set<Tuple> zrangeWithScores(String key , long start , long end) {
		Jedis jedis = null;
		Set<Tuple> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.zrangeWithScores(key , start , end);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Set<Tuple> zrevrangeWithScores(String key , long start , long end) {
		Jedis jedis = null;
		Set<Tuple> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.zrevrangeWithScores(key , start , end);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long zcard(String key) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.zcard(key);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Double zscore(String key , String member) {
		Jedis jedis = null;
		Double result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.zscore(key , member);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static String watch(String ... keys) {
		Jedis jedis = null;
		String result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.watch(keys);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static List<String> sort(String key) {
		Jedis jedis = null;
		List<String> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.sort(key);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static List<String> sort(String key , SortingParams sortingParameters) {
		Jedis jedis = null;
		List<String> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.sort(key , sortingParameters);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static List<String> blpop(int timeout , String ... keys) {
		Jedis jedis = null;
		List<String> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.blpop(timeout , keys);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static List<String> blpop(String ... args) {
		Jedis jedis = null;
		List<String> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.blpop(args);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static List<String> brpop(String ... args) {
		Jedis jedis = null;
		List<String> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.brpop(args);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long sort(String key , SortingParams sortingParameters , String dstkey) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.sort(key , sortingParameters , dstkey);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long sort(String key , String dstkey) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.sort(key , dstkey);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static List<String> brpop(int timeout , String ... keys) {
		Jedis jedis = null;
		List<String> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.brpop(timeout , keys);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long zcount(String key , double min , double max) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.zcount(key , min , max);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long zcount(String key , String min , String max) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.zcount(key , min , max);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Set<String> zrangeByScore(String key , double min , double max) {
		Jedis jedis = null;
		Set<String> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.zrangeByScore(key , min , max);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Set<String> zrangeByScore(String key , String min , String max) {
		Jedis jedis = null;
		Set<String> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.zrangeByScore(key , min , max);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Set<String> zrangeByScore(String key , double min , double max , int offset , int count) {
		Jedis jedis = null;
		Set<String> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.zrangeByScore(key , min , max , offset , count);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Set<String> zrangeByScore(String key , String min , String max , int offset , int count) {
		Jedis jedis = null;
		Set<String> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.zrangeByScore(key , min , max , offset , count);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Set<Tuple> zrangeByScoreWithScores(String key , double min , double max) {
		Jedis jedis = null;
		Set<Tuple> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.zrangeByScoreWithScores(key , min , max);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Set<Tuple> zrangeByScoreWithScores(String key , String min , String max) {
		Jedis jedis = null;
		Set<Tuple> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.zrangeByScoreWithScores(key , min , max);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Set<Tuple> zrangeByScoreWithScores(String key , double min , double max , int offset , int count) {
		Jedis jedis = null;
		Set<Tuple> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.zrangeByScoreWithScores(key , min , max , offset , count);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Set<Tuple> zrangeByScoreWithScores(String key , String min , String max , int offset , int count) {
		Jedis jedis = null;
		Set<Tuple> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.zrangeByScoreWithScores(key , min , max , offset , count);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Set<String> zrevrangeByScore(String key , double max , double min) {
		Jedis jedis = null;
		Set<String> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.zrevrangeByScore(key , max , min);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Set<String> zrevrangeByScore(String key , String max , String min) {
		Jedis jedis = null;
		Set<String> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.zrevrangeByScore(key , max , min);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Set<String> zrevrangeByScore(String key , double max , double min , int offset , int count) {
		Jedis jedis = null;
		Set<String> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.zrevrangeByScore(key , max , min , offset , count);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Set<Tuple> zrevrangeByScoreWithScores(String key , double max , double min) {
		Jedis jedis = null;
		Set<Tuple> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.zrevrangeByScoreWithScores(key , max , min);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Set<Tuple> zrevrangeByScoreWithScores(String key , double max , double min , int offset , int count) {
		Jedis jedis = null;
		Set<Tuple> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.zrevrangeByScoreWithScores(key , max , min , offset , count);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Set<Tuple> zrevrangeByScoreWithScores(String key , String max , String min , int offset , int count) {
		Jedis jedis = null;
		Set<Tuple> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.zrevrangeByScoreWithScores(key , max , min , offset , count);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Set<String> zrevrangeByScore(String key , String max , String min , int offset , int count) {
		Jedis jedis = null;
		Set<String> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.zrevrangeByScore(key , max , min , offset , count);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Set<Tuple> zrevrangeByScoreWithScores(String key , String max , String min) {
		Jedis jedis = null;
		Set<Tuple> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.zrevrangeByScoreWithScores(key , max , min);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long zremrangeByRank(String key , long start , long end) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.zremrangeByRank(key , start , end);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long zremrangeByScore(String key , double start , double end) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.zremrangeByScore(key , start , end);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long zremrangeByScore(String key , String start , String end) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.zremrangeByScore(key , start , end);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long zunionstore(String dstkey , String ... sets) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.zunionstore(dstkey , sets);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long zunionstore(String dstkey , ZParams params , String ... sets) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.zunionstore(dstkey , params , sets);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long zinterstore(String dstkey , String ... sets) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.zinterstore(dstkey , sets);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long zinterstore(String dstkey , ZParams params , String ... sets) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.zinterstore(dstkey , params , sets);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long zlexcount(String key , String min , String max) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.zlexcount(key , min , max);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Set<String> zrangeByLex(String key , String min , String max) {
		Jedis jedis = null;
		Set<String> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.zrangeByLex(key , min , max);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Set<String> zrangeByLex(String key , String min , String max , int offset , int count) {
		Jedis jedis = null;
		Set<String> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.zrangeByLex(key , min , max , offset , count);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Set<String> zrevrangeByLex(String key , String max , String min) {
		Jedis jedis = null;
		Set<String> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.zrevrangeByLex(key , max , min);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Set<String> zrevrangeByLex(String key , String max , String min , int offset , int count) {
		Jedis jedis = null;
		Set<String> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.zrevrangeByLex(key , max , min , offset , count);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long zremrangeByLex(String key , String min , String max) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.zremrangeByLex(key , min , max);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long strlen(String key) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.strlen(key);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long lpushx(String key , String ... string) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.lpushx(key , string);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long persist(String key) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.persist(key);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long rpushx(String key , String ... string) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.rpushx(key , string);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static String echo(String string) {
		Jedis jedis = null;
		String result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.echo(string);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long linsert(String key , LIST_POSITION where , String pivot , String value) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.linsert(key , where , pivot , value);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static String brpoplpush(String source , String destination , int timeout) {
		Jedis jedis = null;
		String result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.brpoplpush(source , destination , timeout);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Boolean setbit(String key , long offset , boolean value) {
		Jedis jedis = null;
		Boolean result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.setbit(key , offset , value);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Boolean setbit(String key , long offset , String value) {
		Jedis jedis = null;
		Boolean result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.setbit(key , offset , value);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Boolean getbit(String key , long offset) {
		Jedis jedis = null;
		Boolean result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.getbit(key , offset);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long setrange(String key , long offset , String value) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.setrange(key , offset , value);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static String getrange(String key , long startOffset , long endOffset) {
		Jedis jedis = null;
		String result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.getrange(key , startOffset , endOffset);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long bitpos(String key , boolean value) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.bitpos(key , value);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long bitpos(String key , boolean value , BitPosParams params) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.bitpos(key , value , params);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static List<String> configGet(String pattern) {
		Jedis jedis = null;
		List<String> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.configGet(pattern);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static String configSet(String parameter , String value) {
		Jedis jedis = null;
		String result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.configSet(parameter , value);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Object eval(String script , int keyCount , String ... params) {
		Jedis jedis = null;
		Object result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.eval(script , keyCount , params);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static void subscribe(JedisPubSub jedisPubSub , String ... channels) {
		Jedis jedis = null;
		try {
			jedis = RedisFactory.getJedis();
			jedis.subscribe(jedisPubSub , channels);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
	}

	public static Long publish(String channel , String message) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.publish(channel , message);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static void psubscribe(JedisPubSub jedisPubSub , String ... patterns) {
		Jedis jedis = null;
		try {
			jedis = RedisFactory.getJedis();
			jedis.psubscribe(jedisPubSub , patterns);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
	}

	public static Object eval(String script , List<String> keys , List<String> args) {
		Jedis jedis = null;
		Object result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.eval(script , keys , args);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Object eval(String script) {
		Jedis jedis = null;
		Object result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.eval(script);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Object evalsha(String script) {
		Jedis jedis = null;
		Object result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.evalsha(script);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Object evalsha(String sha1 , List<String> keys , List<String> args) {
		Jedis jedis = null;
		Object result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.evalsha(sha1 , keys , args);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Object evalsha(String sha1 , int keyCount , String ... params) {
		Jedis jedis = null;
		Object result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.evalsha(sha1 , keyCount , params);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Boolean scriptExists(String sha1) {
		Jedis jedis = null;
		Boolean result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.scriptExists(sha1);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static List<Boolean> scriptExists(String ... sha1) {
		Jedis jedis = null;
		List<Boolean> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.scriptExists(sha1);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static String scriptLoad(String script) {
		Jedis jedis = null;
		String result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.scriptLoad(script);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static List<Slowlog> slowlogGet() {
		Jedis jedis = null;
		List<Slowlog> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.slowlogGet();
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static List<Slowlog> slowlogGet(long entries) {
		Jedis jedis = null;
		List<Slowlog> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.slowlogGet(entries);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long objectRefcount(String string) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.objectRefcount(string);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static String objectEncoding(String string) {
		Jedis jedis = null;
		String result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.objectEncoding(string);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long objectIdletime(String string) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.objectIdletime(string);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long bitcount(String key) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.bitcount(key);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long bitcount(String key , long start , long end) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.bitcount(key , start , end);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long bitop(BitOP op , String destKey , String ... srcKeys) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.bitop(op , destKey , srcKeys);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static List<Map<String , String>> sentinelMasters() {
		Jedis jedis = null;
		List<Map<String , String>> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.sentinelMasters();
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static List<String> sentinelGetMasterAddrByName(String masterName) {
		Jedis jedis = null;
		List<String> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.sentinelGetMasterAddrByName(masterName);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long sentinelReset(String pattern) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.sentinelReset(pattern);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static List<Map<String , String>> sentinelSlaves(String masterName) {
		Jedis jedis = null;
		List<Map<String , String>> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.sentinelSlaves(masterName);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static String sentinelFailover(String masterName) {
		Jedis jedis = null;
		String result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.sentinelFailover(masterName);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static String sentinelMonitor(String masterName , String ip , int port , int quorum) {
		Jedis jedis = null;
		String result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.sentinelMonitor(masterName , ip , port , quorum);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static String sentinelRemove(String masterName) {
		Jedis jedis = null;
		String result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.sentinelRemove(masterName);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static String sentinelSet(String masterName , Map<String , String> parameterMap) {
		Jedis jedis = null;
		String result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.sentinelSet(masterName , parameterMap);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static byte [] dump(String key) {
		Jedis jedis = null;
		byte [] result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.dump(key);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static String restore(String key , int ttl , byte [] serializedValue) {
		Jedis jedis = null;
		String result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.restore(key , ttl , serializedValue);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long pexpire(String key , long milliseconds) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.pexpire(key , milliseconds);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long pexpireAt(String key , long millisecondsTimestamp) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.pexpireAt(key , millisecondsTimestamp);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long pttl(String key) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.pttl(key);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static String psetex(String key , long milliseconds , String value) {
		Jedis jedis = null;
		String result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.psetex(key , milliseconds , value);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static String set(String key , String value , String nxxx) {
		Jedis jedis = null;
		String result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.set(key , value , nxxx);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static String set(String key , String value , String nxxx , String expx , int time) {
		Jedis jedis = null;
		String result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.set(key , value , nxxx , expx , time);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static String clientKill(String client) {
		Jedis jedis = null;
		String result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.clientKill(client);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static String clientSetname(String name) {
		Jedis jedis = null;
		String result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.clientSetname(name);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static String migrate(String host , int port , String key , int destinationDb , int timeout) {
		Jedis jedis = null;
		String result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.migrate(host , port , key , destinationDb , timeout);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static ScanResult<String> scan(String cursor) {
		Jedis jedis = null;
		ScanResult<String> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.scan(cursor);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static ScanResult<String> scan(String cursor , ScanParams params) {
		Jedis jedis = null;
		ScanResult<String> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.scan(cursor , params);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static ScanResult<Entry<String , String>> hscan(String key , String cursor) {
		Jedis jedis = null;
		ScanResult<Entry<String , String>> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.hscan(key , cursor);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static ScanResult<Entry<String , String>> hscan(String key , String cursor , ScanParams params) {
		Jedis jedis = null;
		ScanResult<Entry<String , String>> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.hscan(key , cursor , params);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static ScanResult<String> sscan(String key , String cursor) {
		Jedis jedis = null;
		ScanResult<String> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.sscan(key , cursor);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static ScanResult<String> sscan(String key , String cursor , ScanParams params) {
		Jedis jedis = null;
		ScanResult<String> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.sscan(key , cursor , params);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static ScanResult<Tuple> zscan(String key , String cursor) {
		Jedis jedis = null;
		ScanResult<Tuple> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.zscan(key , cursor);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static ScanResult<Tuple> zscan(String key , String cursor , ScanParams params) {
		Jedis jedis = null;
		ScanResult<Tuple> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.zscan(key , cursor , params);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static String clusterNodes() {
		Jedis jedis = null;
		String result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.clusterNodes();
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static String readonly() {
		Jedis jedis = null;
		String result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.readonly();
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static String clusterMeet(String ip , int port) {
		Jedis jedis = null;
		String result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.clusterMeet(ip , port);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static String clusterReset(Reset resetType) {
		Jedis jedis = null;
		String result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.clusterReset(resetType);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static String clusterAddSlots(int ... slots) {
		Jedis jedis = null;
		String result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.clusterAddSlots(slots);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static String clusterDelSlots(int ... slots) {
		Jedis jedis = null;
		String result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.clusterDelSlots(slots);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static String clusterInfo() {
		Jedis jedis = null;
		String result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.clusterInfo();
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static List<String> clusterGetKeysInSlot(int slot , int count) {
		Jedis jedis = null;
		List<String> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.clusterGetKeysInSlot(slot , count);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static String clusterSetSlotNode(int slot , String nodeId) {
		Jedis jedis = null;
		String result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.clusterSetSlotNode(slot , nodeId);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static String clusterSetSlotMigrating(int slot , String nodeId) {
		Jedis jedis = null;
		String result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.clusterSetSlotMigrating(slot , nodeId);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static String clusterSetSlotImporting(int slot , String nodeId) {
		Jedis jedis = null;
		String result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.clusterSetSlotImporting(slot , nodeId);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static String clusterSetSlotStable(int slot) {
		Jedis jedis = null;
		String result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.clusterSetSlotStable(slot);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static String clusterForget(String nodeId) {
		Jedis jedis = null;
		String result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.clusterForget(nodeId);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static String clusterFlushSlots() {
		Jedis jedis = null;
		String result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.clusterFlushSlots();
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long clusterKeySlot(String key) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.clusterKeySlot(key);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long clusterCountKeysInSlot(int slot) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.clusterCountKeysInSlot(slot);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static String clusterSaveConfig() {
		Jedis jedis = null;
		String result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.clusterSaveConfig();
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static String clusterReplicate(String nodeId) {
		Jedis jedis = null;
		String result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.clusterReplicate(nodeId);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static List<String> clusterSlaves(String nodeId) {
		Jedis jedis = null;
		List<String> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.clusterSlaves(nodeId);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static String clusterFailover() {
		Jedis jedis = null;
		String result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.clusterFailover();
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static List<Object> clusterSlots() {
		Jedis jedis = null;
		List<Object> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.clusterSlots();
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static String asking() {
		Jedis jedis = null;
		String result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.asking();
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static List<String> pubsubChannels(String pattern) {
		Jedis jedis = null;
		List<String> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.pubsubChannels(pattern);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long pubsubNumPat() {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.pubsubNumPat();
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Map<String , String> pubsubNumSub(String ... channels) {
		Jedis jedis = null;
		Map<String , String> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.pubsubNumSub(channels);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static void setDataSource(Pool<Jedis> jedisPool) {
		Jedis jedis = null;
		try {
			jedis = RedisFactory.getJedis();
			jedis.setDataSource(jedisPool);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
	}

	public static Long pfadd(String key , String ... elements) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.pfadd(key , elements);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static long pfcount(String key) {
		Jedis jedis = null;
		long result = 0;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.pfcount(key);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static long pfcount(String ... keys) {
		Jedis jedis = null;
		long result = 0;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.pfcount(keys);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static String pfmerge(String destkey , String ... sourcekeys) {
		Jedis jedis = null;
		String result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.pfmerge(destkey , sourcekeys);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static List<String> blpop(int timeout , String key) {
		Jedis jedis = null;
		List<String> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.blpop(timeout , key);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static List<String> brpop(int timeout , String key) {
		Jedis jedis = null;
		List<String> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.brpop(timeout , key);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long geoadd(String key , double longitude , double latitude , String member) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.geoadd(key , longitude , latitude , member);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long geoadd(String key , Map<String , GeoCoordinate> memberCoordinateMap) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.geoadd(key , memberCoordinateMap);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Double geodist(String key , String member1 , String member2) {
		Jedis jedis = null;
		Double result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.geodist(key , member1 , member2);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Double geodist(String key , String member1 , String member2 , GeoUnit unit) {
		Jedis jedis = null;
		Double result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.geodist(key , member1 , member2 , unit);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static List<String> geohash(String key , String ... members) {
		Jedis jedis = null;
		List<String> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.geohash(key , members);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static List<GeoCoordinate> geopos(String key , String ... members) {
		Jedis jedis = null;
		List<GeoCoordinate> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.geopos(key , members);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static List<GeoRadiusResponse> georadius(String key , double longitude , double latitude , double radius , GeoUnit unit) {
		Jedis jedis = null;
		List<GeoRadiusResponse> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.georadius(key , longitude , latitude , radius , unit);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static List<GeoRadiusResponse> georadius(String key , double longitude , double latitude , double radius , GeoUnit unit , GeoRadiusParam param) {
		Jedis jedis = null;
		List<GeoRadiusResponse> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.georadius(key , longitude , latitude , radius , unit , param);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static List<GeoRadiusResponse> georadiusByMember(String key , String member , double radius , GeoUnit unit) {
		Jedis jedis = null;
		List<GeoRadiusResponse> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.georadiusByMember(key , member , radius , unit);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static List<GeoRadiusResponse> georadiusByMember(String key , String member , double radius , GeoUnit unit , GeoRadiusParam param) {
		Jedis jedis = null;
		List<GeoRadiusResponse> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.georadiusByMember(key , member , radius , unit , param);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static List<Long> bitfield(String key , String ... arguments) {
		Jedis jedis = null;
		List<Long> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.bitfield(key , arguments);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static String ping() {
		Jedis jedis = null;
		String result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.ping();
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static String set(byte [] key , byte [] value) {
		Jedis jedis = null;
		String result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.set(key , value);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static String set(byte [] key , byte [] value , byte [] nxxx , byte [] expx , long time) {
		Jedis jedis = null;
		String result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.set(key , value , nxxx , expx , time);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static byte [] get(byte [] key) {
		Jedis jedis = null;
		byte [] result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.get(key);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static String quit() {
		Jedis jedis = null;
		String result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.quit();
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long exists(byte [] ... keys) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.exists(keys);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Boolean exists(byte [] key) {
		Jedis jedis = null;
		Boolean result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.exists(key);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long del(byte [] ... keys) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.del(keys);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long del(byte [] key) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.del(key);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static String type(byte [] key) {
		Jedis jedis = null;
		String result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.type(key);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static String flushDB() {
		Jedis jedis = null;
		String result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.flushDB();
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Set<byte []> keys(byte [] pattern) {
		Jedis jedis = null;
		Set<byte []> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.keys(pattern);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static byte [] randomBinaryKey() {
		Jedis jedis = null;
		byte [] result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.randomBinaryKey();
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static String rename(byte [] oldkey , byte [] newkey) {
		Jedis jedis = null;
		String result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.rename(oldkey , newkey);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long renamenx(byte [] oldkey , byte [] newkey) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.renamenx(oldkey , newkey);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long dbSize() {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.dbSize();
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long expire(byte [] key , int seconds) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.expire(key , seconds);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long expireAt(byte [] key , long unixTime) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.expireAt(key , unixTime);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long ttl(byte [] key) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.ttl(key);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static String select(int index) {
		Jedis jedis = null;
		String result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.select(index);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long move(byte [] key , int dbIndex) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.move(key , dbIndex);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static String flushAll() {
		Jedis jedis = null;
		String result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.flushAll();
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static byte [] getSet(byte [] key , byte [] value) {
		Jedis jedis = null;
		byte [] result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.getSet(key , value);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static List<byte []> mget(byte [] ... keys) {
		Jedis jedis = null;
		List<byte []> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.mget(keys);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long setnx(byte [] key , byte [] value) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.setnx(key , value);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static String setex(byte [] key , int seconds , byte [] value) {
		Jedis jedis = null;
		String result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.setex(key , seconds , value);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static String mset(byte [] ... keysvalues) {
		Jedis jedis = null;
		String result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.mset(keysvalues);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long msetnx(byte [] ... keysvalues) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.msetnx(keysvalues);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long decrBy(byte [] key , long integer) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.decrBy(key , integer);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long decr(byte [] key) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.decr(key);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long incrBy(byte [] key , long integer) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.incrBy(key , integer);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Double incrByFloat(byte [] key , double integer) {
		Jedis jedis = null;
		Double result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.incrByFloat(key , integer);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long incr(byte [] key) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.incr(key);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long append(byte [] key , byte [] value) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.append(key , value);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static byte [] substr(byte [] key , int start , int end) {
		Jedis jedis = null;
		byte [] result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.substr(key , start , end);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long hset(byte [] key , byte [] field , byte [] value) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.hset(key , field , value);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static byte [] hget(byte [] key , byte [] field) {
		Jedis jedis = null;
		byte [] result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.hget(key , field);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long hsetnx(byte [] key , byte [] field , byte [] value) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.hsetnx(key , field , value);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static String hmset(byte [] key , Map<byte [] , byte []> hash) {
		Jedis jedis = null;
		String result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.hmset(key , hash);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static List<byte []> hmget(byte [] key , byte [] ... fields) {
		Jedis jedis = null;
		List<byte []> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.hmget(key , fields);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long hincrBy(byte [] key , byte [] field , long value) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.hincrBy(key , field , value);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Double hincrByFloat(byte [] key , byte [] field , double value) {
		Jedis jedis = null;
		Double result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.hincrByFloat(key , field , value);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Boolean hexists(byte [] key , byte [] field) {
		Jedis jedis = null;
		Boolean result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.hexists(key , field);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long hdel(byte [] key , byte [] ... fields) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.hdel(key , fields);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long hlen(byte [] key) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.hlen(key);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Set<byte []> hkeys(byte [] key) {
		Jedis jedis = null;
		Set<byte []> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.hkeys(key);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static List<byte []> hvals(byte [] key) {
		Jedis jedis = null;
		List<byte []> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.hvals(key);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Map<byte [] , byte []> hgetAll(byte [] key) {
		Jedis jedis = null;
		Map<byte [] , byte []> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.hgetAll(key);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long rpush(byte [] key , byte [] ... strings) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.rpush(key , strings);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long lpush(byte [] key , byte [] ... strings) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.lpush(key , strings);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long llen(byte [] key) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.llen(key);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static List<byte []> lrange(byte [] key , long start , long end) {
		Jedis jedis = null;
		List<byte []> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.lrange(key , start , end);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static String ltrim(byte [] key , long start , long end) {
		Jedis jedis = null;
		String result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.ltrim(key , start , end);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static byte [] lindex(byte [] key , long index) {
		Jedis jedis = null;
		byte [] result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.lindex(key , index);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static String lset(byte [] key , long index , byte [] value) {
		Jedis jedis = null;
		String result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.lset(key , index , value);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long lrem(byte [] key , long count , byte [] value) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.lrem(key , count , value);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static byte [] lpop(byte [] key) {
		Jedis jedis = null;
		byte [] result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.lpop(key);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static byte [] rpop(byte [] key) {
		Jedis jedis = null;
		byte [] result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.rpop(key);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static byte [] rpoplpush(byte [] srckey , byte [] dstkey) {
		Jedis jedis = null;
		byte [] result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.rpoplpush(srckey , dstkey);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long sadd(byte [] key , byte [] ... members) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.sadd(key , members);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Set<byte []> smembers(byte [] key) {
		Jedis jedis = null;
		Set<byte []> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.smembers(key);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long srem(byte [] key , byte [] ... member) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.srem(key , member);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static byte [] spop(byte [] key) {
		Jedis jedis = null;
		byte [] result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.spop(key);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Set<byte []> spop(byte [] key , long count) {
		Jedis jedis = null;
		Set<byte []> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.spop(key , count);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long smove(byte [] srckey , byte [] dstkey , byte [] member) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.smove(srckey , dstkey , member);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long scard(byte [] key) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.scard(key);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Boolean sismember(byte [] key , byte [] member) {
		Jedis jedis = null;
		Boolean result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.sismember(key , member);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Set<byte []> sinter(byte [] ... keys) {
		Jedis jedis = null;
		Set<byte []> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.sinter(keys);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long sinterstore(byte [] dstkey , byte [] ... keys) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.sinterstore(dstkey , keys);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Set<byte []> sunion(byte [] ... keys) {
		Jedis jedis = null;
		Set<byte []> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.sunion(keys);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long sunionstore(byte [] dstkey , byte [] ... keys) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.sunionstore(dstkey , keys);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Set<byte []> sdiff(byte [] ... keys) {
		Jedis jedis = null;
		Set<byte []> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.sdiff(keys);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long sdiffstore(byte [] dstkey , byte [] ... keys) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.sdiffstore(dstkey , keys);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static byte [] srandmember(byte [] key) {
		Jedis jedis = null;
		byte [] result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.srandmember(key);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static List<byte []> srandmember(byte [] key , int count) {
		Jedis jedis = null;
		List<byte []> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.srandmember(key , count);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long zadd(byte [] key , double score , byte [] member) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.zadd(key , score , member);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long zadd(byte [] key , double score , byte [] member , ZAddParams params) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.zadd(key , score , member , params);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long zadd(byte [] key , Map<byte [] , Double> scoreMembers) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.zadd(key , scoreMembers);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long zadd(byte [] key , Map<byte [] , Double> scoreMembers , ZAddParams params) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.zadd(key , scoreMembers , params);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Set<byte []> zrange(byte [] key , long start , long end) {
		Jedis jedis = null;
		Set<byte []> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.zrange(key , start , end);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long zrem(byte [] key , byte [] ... members) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.zrem(key , members);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Double zincrby(byte [] key , double score , byte [] member) {
		Jedis jedis = null;
		Double result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.zincrby(key , score , member);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Double zincrby(byte [] key , double score , byte [] member , ZIncrByParams params) {
		Jedis jedis = null;
		Double result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.zincrby(key , score , member , params);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long zrank(byte [] key , byte [] member) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.zrank(key , member);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long zrevrank(byte [] key , byte [] member) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.zrevrank(key , member);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Set<byte []> zrevrange(byte [] key , long start , long end) {
		Jedis jedis = null;
		Set<byte []> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.zrevrange(key , start , end);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Set<Tuple> zrangeWithScores(byte [] key , long start , long end) {
		Jedis jedis = null;
		Set<Tuple> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.zrangeWithScores(key , start , end);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Set<Tuple> zrevrangeWithScores(byte [] key , long start , long end) {
		Jedis jedis = null;
		Set<Tuple> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.zrevrangeWithScores(key , start , end);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long zcard(byte [] key) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.zcard(key);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Double zscore(byte [] key , byte [] member) {
		Jedis jedis = null;
		Double result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.zscore(key , member);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Transaction multi() {
		Jedis jedis = null;
		Transaction result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.multi();
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static void connect() {
		Jedis jedis = null;
		try {
			jedis = RedisFactory.getJedis();
			jedis.connect();
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
	}

	public static void disconnect() {
		Jedis jedis = null;
		try {
			jedis = RedisFactory.getJedis();
			jedis.disconnect();
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
	}

	public static void resetState() {
		Jedis jedis = null;
		try {
			jedis = RedisFactory.getJedis();
			jedis.resetState();
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
	}

	public static String watch(byte [] ... keys) {
		Jedis jedis = null;
		String result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.watch(keys);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static String unwatch() {
		Jedis jedis = null;
		String result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.unwatch();
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static List<byte []> sort(byte [] key) {
		Jedis jedis = null;
		List<byte []> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.sort(key);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static List<byte []> sort(byte [] key , SortingParams sortingParameters) {
		Jedis jedis = null;
		List<byte []> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.sort(key , sortingParameters);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static List<byte []> blpop(int timeout , byte [] ... keys) {
		Jedis jedis = null;
		List<byte []> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.blpop(timeout , keys);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long sort(byte [] key , SortingParams sortingParameters , byte [] dstkey) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.sort(key , sortingParameters , dstkey);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long sort(byte [] key , byte [] dstkey) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.sort(key , dstkey);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static List<byte []> brpop(int timeout , byte [] ... keys) {
		Jedis jedis = null;
		List<byte []> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.brpop(timeout , keys);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static List<byte []> blpop(byte [] ... args) {
		Jedis jedis = null;
		List<byte []> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.blpop(args);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static List<byte []> brpop(byte [] ... args) {
		Jedis jedis = null;
		List<byte []> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.brpop(args);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static String auth(String password) {
		Jedis jedis = null;
		String result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.auth(password);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Pipeline pipelined() {
		Jedis jedis = null;
		Pipeline result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.pipelined();
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long zcount(byte [] key , double min , double max) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.zcount(key , min , max);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long zcount(byte [] key , byte [] min , byte [] max) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.zcount(key , min , max);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Set<byte []> zrangeByScore(byte [] key , double min , double max) {
		Jedis jedis = null;
		Set<byte []> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.zrangeByScore(key , min , max);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Set<byte []> zrangeByScore(byte [] key , byte [] min , byte [] max) {
		Jedis jedis = null;
		Set<byte []> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.zrangeByScore(key , min , max);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Set<byte []> zrangeByScore(byte [] key , double min , double max , int offset , int count) {
		Jedis jedis = null;
		Set<byte []> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.zrangeByScore(key , min , max , offset , count);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Set<byte []> zrangeByScore(byte [] key , byte [] min , byte [] max , int offset , int count) {
		Jedis jedis = null;
		Set<byte []> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.zrangeByScore(key , min , max , offset , count);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Set<Tuple> zrangeByScoreWithScores(byte [] key , double min , double max) {
		Jedis jedis = null;
		Set<Tuple> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.zrangeByScoreWithScores(key , min , max);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Set<Tuple> zrangeByScoreWithScores(byte [] key , byte [] min , byte [] max) {
		Jedis jedis = null;
		Set<Tuple> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.zrangeByScoreWithScores(key , min , max);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Set<Tuple> zrangeByScoreWithScores(byte [] key , double min , double max , int offset , int count) {
		Jedis jedis = null;
		Set<Tuple> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.zrangeByScoreWithScores(key , min , max , offset , count);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Set<Tuple> zrangeByScoreWithScores(byte [] key , byte [] min , byte [] max , int offset , int count) {
		Jedis jedis = null;
		Set<Tuple> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.zrangeByScoreWithScores(key , min , max , offset , count);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Set<byte []> zrevrangeByScore(byte [] key , double max , double min) {
		Jedis jedis = null;
		Set<byte []> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.zrevrangeByScore(key , max , min);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Set<byte []> zrevrangeByScore(byte [] key , byte [] max , byte [] min) {
		Jedis jedis = null;
		Set<byte []> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.zrevrangeByScore(key , max , min);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Set<byte []> zrevrangeByScore(byte [] key , double max , double min , int offset , int count) {
		Jedis jedis = null;
		Set<byte []> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.zrevrangeByScore(key , max , min , offset , count);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Set<byte []> zrevrangeByScore(byte [] key , byte [] max , byte [] min , int offset , int count) {
		Jedis jedis = null;
		Set<byte []> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.zrevrangeByScore(key , max , min , offset , count);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Set<Tuple> zrevrangeByScoreWithScores(byte [] key , double max , double min) {
		Jedis jedis = null;
		Set<Tuple> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.zrevrangeByScoreWithScores(key , max , min);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Set<Tuple> zrevrangeByScoreWithScores(byte [] key , double max , double min , int offset , int count) {
		Jedis jedis = null;
		Set<Tuple> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.zrevrangeByScoreWithScores(key , max , min , offset , count);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Set<Tuple> zrevrangeByScoreWithScores(byte [] key , byte [] max , byte [] min) {
		Jedis jedis = null;
		Set<Tuple> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.zrevrangeByScoreWithScores(key , max , min);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Set<Tuple> zrevrangeByScoreWithScores(byte [] key , byte [] max , byte [] min , int offset , int count) {
		Jedis jedis = null;
		Set<Tuple> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.zrevrangeByScoreWithScores(key , max , min , offset , count);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long zremrangeByRank(byte [] key , long start , long end) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.zremrangeByRank(key , start , end);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long zremrangeByScore(byte [] key , double start , double end) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.zremrangeByScore(key , start , end);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long zremrangeByScore(byte [] key , byte [] start , byte [] end) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.zremrangeByScore(key , start , end);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long zunionstore(byte [] dstkey , byte [] ... sets) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.zunionstore(dstkey , sets);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long zunionstore(byte [] dstkey , ZParams params , byte [] ... sets) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.zunionstore(dstkey , params , sets);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long zinterstore(byte [] dstkey , byte [] ... sets) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.zinterstore(dstkey , sets);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long zinterstore(byte [] dstkey , ZParams params , byte [] ... sets) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.zinterstore(dstkey , params , sets);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long zlexcount(byte [] key , byte [] min , byte [] max) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.zlexcount(key , min , max);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Set<byte []> zrangeByLex(byte [] key , byte [] min , byte [] max) {
		Jedis jedis = null;
		Set<byte []> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.zrangeByLex(key , min , max);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Set<byte []> zrangeByLex(byte [] key , byte [] min , byte [] max , int offset , int count) {
		Jedis jedis = null;
		Set<byte []> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.zrangeByLex(key , min , max , offset , count);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Set<byte []> zrevrangeByLex(byte [] key , byte [] max , byte [] min) {
		Jedis jedis = null;
		Set<byte []> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.zrevrangeByLex(key , max , min);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Set<byte []> zrevrangeByLex(byte [] key , byte [] max , byte [] min , int offset , int count) {
		Jedis jedis = null;
		Set<byte []> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.zrevrangeByLex(key , max , min , offset , count);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long zremrangeByLex(byte [] key , byte [] min , byte [] max) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.zremrangeByLex(key , min , max);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static String save() {
		Jedis jedis = null;
		String result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.save();
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static String bgsave() {
		Jedis jedis = null;
		String result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.bgsave();
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static String bgrewriteaof() {
		Jedis jedis = null;
		String result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.bgrewriteaof();
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long lastsave() {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.lastsave();
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static String shutdown() {
		Jedis jedis = null;
		String result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.shutdown();
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static String info() {
		Jedis jedis = null;
		String result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.info();
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static String info(String section) {
		Jedis jedis = null;
		String result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.info(section);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static void monitor(JedisMonitor jedisMonitor) {
		Jedis jedis = null;
		try {
			jedis = RedisFactory.getJedis();
			jedis.monitor(jedisMonitor);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
	}

	public static String slaveof(String host , int port) {
		Jedis jedis = null;
		String result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.slaveof(host , port);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static String slaveofNoOne() {
		Jedis jedis = null;
		String result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.slaveofNoOne();
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static List<byte []> configGet(byte [] pattern) {
		Jedis jedis = null;
		List<byte []> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.configGet(pattern);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static String configResetStat() {
		Jedis jedis = null;
		String result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.configResetStat();
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static byte [] configSet(byte [] parameter , byte [] value) {
		Jedis jedis = null;
		byte [] result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.configSet(parameter , value);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static boolean isConnected() {
		Jedis jedis = null;
		boolean result = false;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.isConnected();
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long strlen(byte [] key) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.strlen(key);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static void sync() {
		Jedis jedis = null;
		try {
			jedis = RedisFactory.getJedis();
			jedis.sync();
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
	}

	public static Long lpushx(byte [] key , byte [] ... string) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.lpushx(key , string);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long persist(byte [] key) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.persist(key);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long rpushx(byte [] key , byte [] ... string) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.rpushx(key , string);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static byte [] echo(byte [] string) {
		Jedis jedis = null;
		byte [] result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.echo(string);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long linsert(byte [] key , LIST_POSITION where , byte [] pivot , byte [] value) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.linsert(key , where , pivot , value);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static String debug(DebugParams params) {
		Jedis jedis = null;
		String result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.debug(params);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Client getClient() {
		Jedis jedis = null;
		Client result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.getClient();
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static byte [] brpoplpush(byte [] source , byte [] destination , int timeout) {
		Jedis jedis = null;
		byte [] result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.brpoplpush(source , destination , timeout);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Boolean setbit(byte [] key , long offset , boolean value) {
		Jedis jedis = null;
		Boolean result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.setbit(key , offset , value);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Boolean setbit(byte [] key , long offset , byte [] value) {
		Jedis jedis = null;
		Boolean result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.setbit(key , offset , value);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Boolean getbit(byte [] key , long offset) {
		Jedis jedis = null;
		Boolean result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.getbit(key , offset);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long bitpos(byte [] key , boolean value) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.bitpos(key , value);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long bitpos(byte [] key , boolean value , BitPosParams params) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.bitpos(key , value , params);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long setrange(byte [] key , long offset , byte [] value) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.setrange(key , offset , value);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static byte [] getrange(byte [] key , long startOffset , long endOffset) {
		Jedis jedis = null;
		byte [] result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.getrange(key , startOffset , endOffset);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long publish(byte [] channel , byte [] message) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.publish(channel , message);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static void subscribe(BinaryJedisPubSub jedisPubSub , byte [] ... channels) {
		Jedis jedis = null;
		try {
			jedis = RedisFactory.getJedis();
			jedis.subscribe(jedisPubSub , channels);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
	}

	public static void psubscribe(BinaryJedisPubSub jedisPubSub , byte [] ... patterns) {
		Jedis jedis = null;
		try {
			jedis = RedisFactory.getJedis();
			jedis.psubscribe(jedisPubSub , patterns);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
	}

	public static Long getDB() {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.getDB();
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Object eval(byte [] script , List<byte []> keys , List<byte []> args) {
		Jedis jedis = null;
		Object result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.eval(script , keys , args);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Object eval(byte [] script , byte [] keyCount , byte [] ... params) {
		Jedis jedis = null;
		Object result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.eval(script , keyCount , params);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Object eval(byte [] script , int keyCount , byte [] ... params) {
		Jedis jedis = null;
		Object result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.eval(script , keyCount , params);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Object eval(byte [] script) {
		Jedis jedis = null;
		Object result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.eval(script);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Object evalsha(byte [] sha1) {
		Jedis jedis = null;
		Object result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.evalsha(sha1);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Object evalsha(byte [] sha1 , List<byte []> keys , List<byte []> args) {
		Jedis jedis = null;
		Object result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.evalsha(sha1 , keys , args);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Object evalsha(byte [] sha1 , int keyCount , byte [] ... params) {
		Jedis jedis = null;
		Object result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.evalsha(sha1 , keyCount , params);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static String scriptFlush() {
		Jedis jedis = null;
		String result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.scriptFlush();
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long scriptExists(byte [] sha1) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.scriptExists(sha1);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static List<Long> scriptExists(byte [] ... sha1) {
		Jedis jedis = null;
		List<Long> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.scriptExists(sha1);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static byte [] scriptLoad(byte [] script) {
		Jedis jedis = null;
		byte [] result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.scriptLoad(script);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static String scriptKill() {
		Jedis jedis = null;
		String result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.scriptKill();
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static String slowlogReset() {
		Jedis jedis = null;
		String result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.slowlogReset();
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long slowlogLen() {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.slowlogLen();
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static List<byte []> slowlogGetBinary() {
		Jedis jedis = null;
		List<byte []> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.slowlogGetBinary();
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static List<byte []> slowlogGetBinary(long entries) {
		Jedis jedis = null;
		List<byte []> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.slowlogGetBinary(entries);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long objectRefcount(byte [] key) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.objectRefcount(key);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static byte [] objectEncoding(byte [] key) {
		Jedis jedis = null;
		byte [] result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.objectEncoding(key);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long objectIdletime(byte [] key) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.objectIdletime(key);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long bitcount(byte [] key) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.bitcount(key);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long bitcount(byte [] key , long start , long end) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.bitcount(key , start , end);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long bitop(BitOP op , byte [] destKey , byte [] ... srcKeys) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.bitop(op , destKey , srcKeys);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static byte [] dump(byte [] key) {
		Jedis jedis = null;
		byte [] result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.dump(key);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static String restore(byte [] key , int ttl , byte [] serializedValue) {
		Jedis jedis = null;
		String result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.restore(key , ttl , serializedValue);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long pexpireAt(byte [] key , long millisecondsTimestamp) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.pexpireAt(key , millisecondsTimestamp);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long pttl(byte [] key) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.pttl(key);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static String psetex(byte [] key , long milliseconds , byte [] value) {
		Jedis jedis = null;
		String result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.psetex(key , milliseconds , value);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static String set(byte [] key , byte [] value , byte [] nxxx) {
		Jedis jedis = null;
		String result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.set(key , value , nxxx);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static String set(byte [] key , byte [] value , byte [] nxxx , byte [] expx , int time) {
		Jedis jedis = null;
		String result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.set(key , value , nxxx , expx , time);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static String clientKill(byte [] client) {
		Jedis jedis = null;
		String result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.clientKill(client);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static String clientGetname() {
		Jedis jedis = null;
		String result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.clientGetname();
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static String clientList() {
		Jedis jedis = null;
		String result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.clientList();
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static String clientSetname(byte [] name) {
		Jedis jedis = null;
		String result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.clientSetname(name);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static List<String> time() {
		Jedis jedis = null;
		List<String> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.time();
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static String migrate(byte [] host , int port , byte [] key , int destinationDb , int timeout) {
		Jedis jedis = null;
		String result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.migrate(host , port , key , destinationDb , timeout);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long waitReplicas(int replicas , long timeout) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.waitReplicas(replicas , timeout);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long pfadd(byte [] key , byte [] ... elements) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.pfadd(key , elements);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static long pfcount(byte [] key) {
		Jedis jedis = null;
		long result = 0;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.pfcount(key);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static String pfmerge(byte [] destkey , byte [] ... sourcekeys) {
		Jedis jedis = null;
		String result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.pfmerge(destkey , sourcekeys);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long pfcount(byte [] ... keys) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.pfcount(keys);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static ScanResult<byte []> scan(byte [] cursor) {
		Jedis jedis = null;
		ScanResult<byte []> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.scan(cursor);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static ScanResult<byte []> scan(byte [] cursor , ScanParams params) {
		Jedis jedis = null;
		ScanResult<byte []> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.scan(cursor , params);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static ScanResult<Entry<byte [] , byte []>> hscan(byte [] key , byte [] cursor) {
		Jedis jedis = null;
		ScanResult<Entry<byte [] , byte []>> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.hscan(key , cursor);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static ScanResult<Entry<byte [] , byte []>> hscan(byte [] key , byte [] cursor , ScanParams params) {
		Jedis jedis = null;
		ScanResult<Entry<byte [] , byte []>> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.hscan(key , cursor , params);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static ScanResult<byte []> sscan(byte [] key , byte [] cursor) {
		Jedis jedis = null;
		ScanResult<byte []> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.sscan(key , cursor);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static ScanResult<byte []> sscan(byte [] key , byte [] cursor , ScanParams params) {
		Jedis jedis = null;
		ScanResult<byte []> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.sscan(key , cursor , params);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static ScanResult<Tuple> zscan(byte [] key , byte [] cursor) {
		Jedis jedis = null;
		ScanResult<Tuple> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.zscan(key , cursor);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static ScanResult<Tuple> zscan(byte [] key , byte [] cursor , ScanParams params) {
		Jedis jedis = null;
		ScanResult<Tuple> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.zscan(key , cursor , params);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long geoadd(byte [] key , double longitude , double latitude , byte [] member) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.geoadd(key , longitude , latitude , member);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Long geoadd(byte [] key , Map<byte [] , GeoCoordinate> memberCoordinateMap) {
		Jedis jedis = null;
		Long result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.geoadd(key , memberCoordinateMap);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Double geodist(byte [] key , byte [] member1 , byte [] member2) {
		Jedis jedis = null;
		Double result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.geodist(key , member1 , member2);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static Double geodist(byte [] key , byte [] member1 , byte [] member2 , GeoUnit unit) {
		Jedis jedis = null;
		Double result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.geodist(key , member1 , member2 , unit);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static List<byte []> geohash(byte [] key , byte [] ... members) {
		Jedis jedis = null;
		List<byte []> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.geohash(key , members);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static List<GeoCoordinate> geopos(byte [] key , byte [] ... members) {
		Jedis jedis = null;
		List<GeoCoordinate> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.geopos(key , members);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static List<GeoRadiusResponse> georadius(byte [] key , double longitude , double latitude , double radius , GeoUnit unit) {
		Jedis jedis = null;
		List<GeoRadiusResponse> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.georadius(key , longitude , latitude , radius , unit);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static List<GeoRadiusResponse> georadius(byte [] key , double longitude , double latitude , double radius , GeoUnit unit , GeoRadiusParam param) {
		Jedis jedis = null;
		List<GeoRadiusResponse> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.georadius(key , longitude , latitude , radius , unit , param);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static List<GeoRadiusResponse> georadiusByMember(byte [] key , byte [] member , double radius , GeoUnit unit) {
		Jedis jedis = null;
		List<GeoRadiusResponse> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.georadiusByMember(key , member , radius , unit);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static List<GeoRadiusResponse> georadiusByMember(byte [] key , byte [] member , double radius , GeoUnit unit , GeoRadiusParam param) {
		Jedis jedis = null;
		List<GeoRadiusResponse> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.georadiusByMember(key , member , radius , unit , param);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}

	public static List<byte []> bitfield(byte [] key , byte [] ... arguments) {
		Jedis jedis = null;
		List<byte []> result = null;
		try {
			jedis = RedisFactory.getJedis();
			result = jedis.bitfield(key , arguments);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			if(jedis != null) {
				RedisFactory.close(jedis);
			}
		}
		return result;
	}
}
